package com.ruoyi.mes.service.impl;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.mes.domain.*;
import com.ruoyi.mes.mapper.*;
import com.ruoyi.mes.utils.CodeUtils;
import com.ruoyi.mes.utils.PageInfoUtils;
import com.ruoyi.mes.vo.buy.BuyOrderSelectListVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.mes.service.IBuyOrderService;
import org.springframework.transaction.annotation.Transactional;

/**
 * 采购订单Service业务层处理
 *
 * @author LongAndHao
 * @date 2023-04-04
 */
@Service
public class BuyOrderServiceImpl implements IBuyOrderService {
    @Autowired
    private BuyInhouMapper buyInhouMapper;

    @Autowired
    private BuyNeedMapper buyNeedMapper;

    @Autowired
    private BuyOrderMapper buyOrderMapper;

    @Autowired
    private MtrInfoMapper mtrInfoMapper;

    /**
     * 查询采购订单
     *
     * @param id 采购订单主键
     * @return 采购订单
     */
    @Override
    public BuyOrder selectBuyOrderById(Long id) {
        return buyOrderMapper.selectBuyOrderById(id);
    }

    /**
     * 查询采购订单列表
     *
     * @param buyOrder 采购订单
     * @return 采购订单
     */
    @Override
    public List<BuyOrder> selectBuyOrderList(BuyOrder buyOrder) {
        return buyOrderMapper.selectBuyOrderList(buyOrder);
    }

    /**
     * 新增采购订单
     *
     * @param buyOrder 采购订单
     * @return 结果
     */
    @Override
    public int insertBuyOrder(BuyOrder buyOrder) {
        buyOrder.setCreateTime(DateUtils.getNowDate());
        return buyOrderMapper.insertBuyOrder(buyOrder);
    }

    /**
     * 修改采购订单
     *
     * @param buyOrder 采购订单
     * @return 结果
     */
    @Override
    public int updateBuyOrder(BuyOrder buyOrder) {
        buyOrder.setUpdateTime(DateUtils.getNowDate());
        return buyOrderMapper.updateBuyOrder(buyOrder);
    }

    /**
     * 批量删除采购订单
     *
     * @param ids 需要删除的采购订单主键
     * @return 结果
     */
    @Override
    public int deleteBuyOrderByIds(Long[] ids) {
        return buyOrderMapper.deleteBuyOrderByIds(ids);
    }

    /**
     * 删除采购订单信息
     *
     * @param id 采购订单主键
     * @return 结果
     */
    @Override
    public int deleteBuyOrderById(Long id) {
        return buyOrderMapper.deleteBuyOrderById(id);
    }


    /**
     * 查 - 采购订单分页 - 采购订单编号
     *
     * @param buyOrder
     * @return
     */
    @Override
    public List<BuyOrder> buyOrderList(BuyOrder buyOrder) {
        return buyOrderMapper.buyOrderList(buyOrder);
    }

    /**
     * 删 - 采购订单 - 采购订单id
     *
     * @param id
     * @return
     */
    @Override
    @Transactional
    public AjaxResult deleteBuyOrder(Long id) {
        BuyOrder order = buyOrderMapper.selectBuyOrderById(id);
        //查找采购订单编码相同的集合
        List<BuyOrder> buyOrders = buyOrderMapper.selectBuyOrdersByCode(order.getBuyOrderCode());
        //查找对应的采购需求，需改变状态
        BuyNeed buyNeed = new BuyNeed();
        buyNeed.setNeedCode(buyOrders.get(0).getNeedCode());
        List<BuyNeed> buyNeeds = buyNeedMapper.selectBuyNeedList(buyNeed);
        //删除采购订单
        for (BuyOrder buyOrder : buyOrders) {
            buyOrderMapper.deleteBuyOrderById(buyOrder.getId());
        }
        //更改状态
        for (BuyNeed need : buyNeeds) {
            need.setStatus(0L);//更改为未采购
            buyNeedMapper.updateBuyNeed(need);
        }
        return AjaxResult.success("删除成功!");
    }


    /**
     * 查 - 采购订单 - 采购订单编码相同
     *
     * @param buyOrderCode
     * @return
     */
    @Override
    public List<BuyOrder> selectBuyOrdersByCode(String buyOrderCode) {
        List<BuyOrder> buyOrders = buyOrderMapper.selectBuyOrdersByCode(buyOrderCode);
        if (buyOrders.size() != 0){
            for (BuyOrder buyOrder : buyOrders) {
                MtrInfo mtrInfo = mtrInfoMapper.selectMtrInfoByCode(buyOrder.getMtrCode());
                BigDecimal result = null;
                result = BigDecimal.valueOf(buyOrder.getBuyQuantity()).multiply(mtrInfo.getCost());
                buyOrder.setCost(result);
            }
        }
        return buyOrders;
    }

    /**
     * 到货
     *
     * @param id 采购订单id
     * @return
     */
    @Override
    @Transactional
    public AjaxResult arrival(Long id) {
        BuyOrder buyOrder = buyOrderMapper.selectBuyOrderById(id);
        //更新状态为已到货
        buyOrder.setStatus(1L);
        buyOrder.setCreateTime(DateUtils.getNowDate());
        //新增采购入库记录
        BuyInhou buyInhou = new BuyInhou();
        buyInhou.setBuyId(id);
        buyInhou.setInspcType(0L);//默认未入库
        buyInhou.setRemark("测试数据");

        buyInhouMapper.insertBuyInhou(buyInhou);
        buyOrderMapper.updateBuyOrder(buyOrder);
        return AjaxResult.success("到货成功!");
    }

    /**
     * 改 - 采购订单 - 采购订单list
     *
     * @param buyOrderList
     * @return
     */
    @Override
    @Transactional
    public int batchUpdata(List<BuyOrder> buyOrderList) {
        int i = 0;
        for (BuyOrder buyOrder : buyOrderList) {
            buyOrder.setUpdateTime(DateUtils.getNowDate());
            i += buyOrderMapper.updateBuyOrder(buyOrder);
        }
        return i;

    }

    /**
     * 增 - 采购订单 - 采购订单list
     *
     * @param buyOrderList
     * @return
     */
    @Override
    @Transactional
    public int addBuyOrder(List<BuyOrder> buyOrderList) {
        String s = CodeUtils.BuyOrderCodeCreat();
        int i = 0;
        for (BuyOrder order : buyOrderList) {
            order.setBuyOrderCode(s);
            order.setStatus(0L);
            i += buyOrderMapper.insertBuyOrder(order);
        }
        return i;
    }

    /**
     * 修改采购订单分页数据
     * @param buyOrderList
     * @return
     */
    @Override
    @Transactional
    public List<BuyOrderSelectListVo> modifyingPagingData(List<BuyOrder> buyOrderList) {
        List<BuyOrderSelectListVo> listCope = new ArrayList<>();
        for (BuyOrder order : buyOrderList) {
            BuyOrderSelectListVo buyOrderSelectListVo = new BuyOrderSelectListVo();
            BeanUtils.copyProperties(order, buyOrderSelectListVo);
            List<String> mtrNameList = new ArrayList<>();
            List<BuyOrder> buyOrders = selectBuyOrdersByCode(order.getBuyOrderCode());
            int count1 = 0;
            BigDecimal totalCost = new BigDecimal("0.0");//总成本
            for (BuyOrder buyOrder1 : buyOrders) {
                count1 += buyOrder1.getStatus();
                mtrNameList.add(buyOrder1.getMtrName());
                //计算成本
                MtrInfo mtrInfo = mtrInfoMapper.selectMtrInfoByCode(buyOrder1.getMtrCode());
                BigDecimal result = null;
                result = BigDecimal.valueOf(buyOrder1.getBuyQuantity()).multiply(mtrInfo.getCost());
                totalCost = totalCost.add(result);
            }
            //到货状态
            if (count1 < buyOrders.size() && count1 != 0) {
                buyOrderSelectListVo.setStatus(1L);
            } else if (count1 == 0) {
                buyOrderSelectListVo.setStatus(0L);
            } else {
                buyOrderSelectListVo.setStatus(2L);
            }

            buyOrderSelectListVo.setBudgetedCost(totalCost);
            buyOrderSelectListVo.setMtrNameList(mtrNameList);
            listCope.add(buyOrderSelectListVo);
        }
        return PageInfoUtils.toPageInfo(buyOrderList,listCope);
    }


}
